{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**.\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max}$$\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use ε-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update. \n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the q(s,a) for all the actions in the state `s`. It is denoted as $ \\hat{q}(s_t,a; w_{t}) $, where $w_{t}$ is the weigths of the neural network which we are trying to learn as part of DQN learning. \n",
    "\n",
    "We use two networks, one target network to get the max q-value of next state denoted by $ \\max_a \\hat {q}(s_{t+1},a; w^{-}_{t}) $ and the primary network with weights $w_{t}$ which we are updated based on back propagation of the TD error through the network.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a,w^{-}_{t}) – \\hat{q}(S_t,A_t,w_t)] \\nabla \\hat{q}(S_t,A_t,w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values. \n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions (current state, action, reward, next state) in a buffer. Where each sample is denoted as a tuple: \n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s^{'}_{i}, done_{i})$$\n",
    "\n",
    "Subscript (i) denotes ith sample. We take N samples from experience replay selecting randomly and update the weights. Subscript (t) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gym\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Atari games and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAATAklEQVR4nO3db6yedZ3n8feHUooDKFQOWNsy7Ug1C2Ytk5OuBmeXVXfosutWHzipcU0fkNS4mGhmogszyY4+aGQ3g+6DHU1wJdM4DrVZJVQiu9PpaIwZpRanIC1UKnTk0NoeigwUpdD2uw/OVbkp5/TcPX84/Z3zfiV37uv+Xr/rvr4/Uj69+jvXfe5UFZKkdpwz0w1Iks6MwS1JjTG4JakxBrckNcbglqTGGNyS1JhpC+4kq5PsSbI3yc3TdR5JmmsyHfdxJ5kH/Az4d8AQ8GPgw1W1e8pPJklzzHRdca8C9lbVY1X1IrAJWDNN55KkOeXcaXrfxcATPa+HgH811uBLL720li1bNk2tSFJ79u3bx1NPPZXR9k1XcI92slesySRZD6wHuOKKK9ixY8c0tSJJ7RkcHBxz33QtlQwBS3teLwH29w6oqturarCqBgcGBqapDUmafaYruH8MrEiyPMl5wFpgyzSdS5LmlGlZKqmqY0k+Afw/YB5wR1Xtmo5zSdJcM11r3FTVd4DvTNf7S9Jc5ScnJakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1ZlJfXZZkH/AccBw4VlWDSRYC3wCWAfuAP6qqX02uTUnSSVNxxf1vq2plVQ12r28GtlXVCmBb91qSNEWmY6lkDbCx294IfGAaziFJc9Zkg7uAv01yf5L1Xe3yqjoA0D1fNslzSJJ6TGqNG7i2qvYnuQzYmuSRfg/sgn49wBVXXDHJNiRp7pjUFXdV7e+eDwF3AauAg0kWAXTPh8Y49vaqGqyqwYGBgcm0IUlzyoSDO8kFSS46uQ38IfAQsAVY1w1bB9w92SYlSS+bzFLJ5cBdSU6+z99U1f9N8mNgc5IbgV8AH5p8m5KkkyYc3FX1GPCOUeqHgfdOpilJ0tj85KQkNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUmHGDO8kdSQ4leaintjDJ1iSPds+X9Oy7JcneJHuSXD9djUvSXNXPFfdfAatPqd0MbKuqFcC27jVJrgLWAld3x3wpybwp61aSNH5wV9X3gadPKa8BNnbbG4EP9NQ3VdXRqnoc2AusmppWJUkw8TXuy6vqAED3fFlXXww80TNuqKu9SpL1SXYk2TE8PDzBNiRp7pnqH05mlFqNNrCqbq+qwaoaHBgYmOI2JGn2mmhwH0yyCKB7PtTVh4ClPeOWAPsn3p4k6VQTDe4twLpuex1wd099bZIFSZYDK4Dtk2tRktTr3PEGJLkTuA64NMkQ8OfArcDmJDcCvwA+BFBVu5JsBnYDx4Cbqur4NPUuSXPSuMFdVR8eY9d7xxi/AdgwmaYkSWPzk5OS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhozbnAnuSPJoSQP9dQ+m+TJJDu7xw09+25JsjfJniTXT1fjkjRX9XPF/VfA6lHqX6yqld3jOwBJrgLWAld3x3wpybypalaS1EdwV9X3gaf7fL81wKaqOlpVjwN7gVWT6E+SdIrJrHF/IsmD3VLKJV1tMfBEz5ihrvYqSdYn2ZFkx/Dw8CTakKS5ZaLB/WXgLcBK4ABwW1fPKGNrtDeoqturarCqBgcGBibYhiTNPRMK7qo6WFXHq+oE8BVeXg4ZApb2DF0C7J9ci5KkXhMK7iSLel5+EDh5x8kWYG2SBUmWAyuA7ZNrUZLU69zxBiS5E7gOuDTJEPDnwHVJVjKyDLIP+BhAVe1KshnYDRwDbqqq49PSuSTNUeMGd1V9eJTyV08zfgOwYTJNSZLG5icnJakxBrckNcbglqTGGNyS1BiDW5IaY3BLPY4++xTP7d/D8ZeOznQr0pjGvR1QmksOP/pDDtx/Dxe+6UrOOfc8AOYtuIBl163jnHnzZ7g7aYTBLY3iyC/3/nb73Ne9njpxAvwFxTpLuFQiSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTHjBneSpUm+m+ThJLuSfLKrL0yyNcmj3fMlPcfckmRvkj1Jrp/OCUhT5dgLz/Orn9//qvr833kDidc4Onv086fxGPAnVfUvgHcCNyW5CrgZ2FZVK4Bt3Wu6fWuBq4HVwJeS+FsedNarE8d48cjhV9UHrvo3ZJ6/1kdnj3GDu6oOVNVPuu3ngIeBxcAaYGM3bCPwgW57DbCpqo5W1ePAXmDVFPctvaaSzHQL0m+d0b//kiwDrgHuAy6vqgMwEu7AZd2wxcATPYcNdbVT32t9kh1JdgwPD0+gdUmam/oO7iQXAt8EPlVVz55u6Ci1elWh6vaqGqyqwYGBgX7bkKQ5r6/gTjKfkdD+elV9qysfTLKo278IONTVh4ClPYcvAfZPTbuSpH7uKgnwVeDhqvpCz64twLpuex1wd099bZIFSZYDK4DtU9eyJM1t/fyo/Frgo8BPk+zsan8K3ApsTnIj8AvgQwBVtSvJZmA3I3ek3FRVx6e6cUmaq8YN7qr6AaOvWwO8d4xjNgAbJtGXJGkMfqpAkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbqnzq8fu58TxY6+ozf+di7nozW+boY6k0RncUuc3Tz8JdeIVtXnnnc+C1186Qx1JozO4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmP6+bLgpUm+m+ThJLuSfLKrfzbJk0l2do8beo65JcneJHuSXD+dE5CkuaafLws+BvxJVf0kyUXA/Um2dvu+WFV/0Ts4yVXAWuBq4M3A3yV5q18YLElTY9wr7qo6UFU/6bafAx4GFp/mkDXApqo6WlWPA3uBVVPRrCTpDNe4kywDrgHu60qfSPJgkjuSXNLVFgNP9Bw2xOmDXpJ0BvoO7iQXAt8EPlVVzwJfBt4CrAQOALedHDrK4TXK+61PsiPJjuHh4TPtW5LmrL6CO8l8RkL761X1LYCqOlhVx6vqBPAVXl4OGQKW9hy+BNh/6ntW1e1VNVhVgwMDA5OZgyTNKf3cVRLgq8DDVfWFnvqinmEfBB7qtrcAa5MsSLIcWAFsn7qWJWlu6+eukmuBjwI/TbKzq/0p8OEkKxlZBtkHfAygqnYl2QzsZuSOlJu8o0SSps64wV1VP2D0devvnOaYDcCGSfQlSRqDn5yUpMYY3JLUGINbAl769bMcOfjYq+oXL1vJ6CuF0swxuCXg+Iu/5oVnDryqfsFlv8fIjVXS2cPglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxvTza12lJj3zzDN8/OMf54UXXhh37BsvmMfH/mAh55zyKcnPf/7z/OzQ0b7Od+utt/K2t71tQr1KZ8Lg1qx19OhRvv3tb/P888+PO/Z3L38D69/9Rxw9cT4nfzfJ/HOO8qMf/YjvP/hPfZ3vM5/5zGTalfpmcEsAhCd/cyW7n3s31a0gXnnBTuDeGe1KGo3BLQG/Pv56fvrPf0DlvN/WnvjNW/nN8QtnsCtpdP5wUgJOVDhe815R+/XxN/DssTfOUEfS2Pr5suDzk2xP8kCSXUk+19UXJtma5NHu+ZKeY25JsjfJniTXT+cEpKkwL8dZcM4rf4h50bmHuWT+L2eoI2ls/VxxHwXeU1XvAFYCq5O8E7gZ2FZVK4Bt3WuSXAWsBa4GVgNfSjJvtDeWzhbn8s+88ej/4fBTP+eF5/dzwbxneMuFD3DeOf3dUSK9lvr5suACjnQv53ePAtYA13X1jcD3gP/a1TdV1VHg8SR7gVXAD8c6x0svvcQvf+mVjabW8PAwI398x7f/qef4L7f+L4q/ZNmbLuYdV76Jf6D42dDhvs/39NNP++dYU+all14ac19fP5zsrpjvB64E/rKq7ktyeVUdAKiqA0ku64YvBn7Uc/hQVxvT4cOH+drXvtZPK1Lfjhw5wrFjx/oef6IKKB4/8DSPH3j6jM937733snv37jM+ThrN4cNjXzT0FdxVdRxYmeRi4K4kbz/N8NG+5+lVlz1J1gPrAa644go+/elP99OK1LeDBw9y22238eKLL74m5/vIRz7Cu971rtfkXJr9vvGNb4y574zuKqmqZxhZElkNHEyyCKB7PtQNGwKW9hy2BNg/ynvdXlWDVTU4MDBwJm1I0pzWz10lA92VNkleB7wPeATYAqzrhq0D7u62twBrkyxIshxYAWyf4r4lac7qZ6lkEbCxW+c+B9hcVfck+SGwOcmNwC+ADwFU1a4km4HdwDHgpm6pRZI0Bfq5q+RB4JpR6oeB945xzAZgw6S7kyS9ip+clKTGGNyS1Bh/yZRmrQULFvD+97+/r9/HPRUWLlz4mpxHMrg1a1188cXceeedM92GNOVcKpGkxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1Jjenny4LPT7I9yQNJdiX5XFf/bJInk+zsHjf0HHNLkr1J9iS5fjonIElzTT+/j/so8J6qOpJkPvCDJPd2+75YVX/ROzjJVcBa4GrgzcDfJXmrXxgsSVNj3CvuGnGkezm/e9RpDlkDbKqqo1X1OLAXWDXpTiVJQJ9r3EnmJdkJHAK2VtV93a5PJHkwyR1JLulqi4Eneg4f6mqSpCnQV3BX1fGqWgksAVYleTvwZeAtwErgAHBbNzyjvcWphSTrk+xIsmN4eHgCrUvS3HRGd5VU1TPA94DVVXWwC/QTwFd4eTlkCFjac9gSYP8o73V7VQ1W1eDAwMBEepekOamfu0oGklzcbb8OeB/wSJJFPcM+CDzUbW8B1iZZkGQ5sALYPqVdS9Ic1s9dJYuAjUnmMRL0m6vqniRfS7KSkWWQfcDHAKpqV5LNwG7gGHCTd5RI0tQZN7ir6kHgmlHqHz3NMRuADZNrTZI0Gj85KUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGpOqmukeSDIMPA88NdO9TINLcV6tma1zc15t+d2qGhhtx1kR3ABJdlTV4Ez3MdWcV3tm69yc1+zhUokkNcbglqTGnE3BfftMNzBNnFd7ZuvcnNcscdascUuS+nM2XXFLkvow48GdZHWSPUn2Jrl5pvs5U0nuSHIoyUM9tYVJtiZ5tHu+pGffLd1c9yS5fma6Hl+SpUm+m+ThJLuSfLKrNz23JOcn2Z7kgW5en+vqTc/rpCTzkvxjknu617NlXvuS/DTJziQ7utqsmNuEVNWMPYB5wM+B3wPOAx4ArprJniYwh38N/D7wUE/tfwA3d9s3A/+9276qm+MCYHk393kzPYcx5rUI+P1u+yLgZ13/Tc8NCHBhtz0fuA94Z+vz6pnfHwN/A9wzW/4sdv3uAy49pTYr5jaRx0xfca8C9lbVY1X1IrAJWDPDPZ2Rqvo+8PQp5TXAxm57I/CBnvqmqjpaVY8Dexn5b3DWqaoDVfWTbvs54GFgMY3PrUYc6V7O7x5F4/MCSLIE+A/A/+4pNz+v05jNczutmQ7uxcATPa+HulrrLq+qAzASgMBlXb3J+SZZBlzDyNVp83PrlhN2AoeArVU1K+YF/E/gM8CJntpsmBeM/OX6t0nuT7K+q82WuZ2xc2f4/BmlNptvc2luvkkuBL4JfKqqnk1Gm8LI0FFqZ+Xcquo4sDLJxcBdSd5+muFNzCvJfwQOVdX9Sa7r55BRamfdvHpcW1X7k1wGbE3yyGnGtja3MzbTV9xDwNKe10uA/TPUy1Q6mGQRQPd8qKs3Nd8k8xkJ7a9X1be68qyYG0BVPQN8D1hN+/O6FvhPSfYxsuT4niR/TfvzAqCq9nfPh4C7GFn6mBVzm4iZDu4fAyuSLE9yHrAW2DLDPU2FLcC6bnsdcHdPfW2SBUmWAyuA7TPQ37gycmn9VeDhqvpCz66m55ZkoLvSJsnrgPcBj9D4vKrqlqpaUlXLGPn/6O+r6j/T+LwAklyQ5KKT28AfAg8xC+Y2YTP901HgBkbuWPg58Gcz3c8E+r8TOAC8xMjf9DcCbwS2AY92zwt7xv9ZN9c9wL+f6f5PM693M/LPyweBnd3jhtbnBvxL4B+7eT0E/Leu3vS8Tpnjdbx8V0nz82LkrrMHuseukzkxG+Y20YefnJSkxsz0Uokk6QwZ3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNeb/A07hpo/JxyF2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden layers with Relu activation and final layer being logits with dimension equal to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 192))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(192, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, 64))\n",
    "        self.network.add_module('relu3', nn.ReLU())\n",
    "        self.network.add_module('layer4', nn.Linear(64, n_actions))\n",
    "        # \n",
    "        self.parameters = self.network.parameters\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, done, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Q-learning\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_w L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t})$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max} w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_td_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x20812942190>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set a seed\n",
    "seed = 13\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state = env.reset()\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "# let us fill experience replay with some samples using full random policy\n",
    "exp_replay = ReplayBuffer(10**4)\n",
    "for i in range(100):\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "    if len(exp_replay) == 10**4:\n",
    "        break\n",
    "print(len(exp_replay))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 5 * 10**4\n",
    "\n",
    "#init Optimizer\n",
    "opt = torch.optim.Adam(agent.parameters(), lr=1e-4)\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 20\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 50001/50001 [04:39<00:00, 178.96it/s]\n"
     ]
    }
   ],
   "source": [
    "state = env.reset()\n",
    "\n",
    "for step in trange(total_steps + 1):\n",
    "    \n",
    "    # reduce exploration as we progress\n",
    "    agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "    # take timesteps_per_epoch and update experience replay buffer\n",
    "    _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "    # train by sampling batch_size of data from experience replay\n",
    "    states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "    \n",
    "\n",
    "    # loss = <compute TD loss>\n",
    "    loss = compute_td_loss(agent, target_network, \n",
    "                           states, actions, rewards, next_states, done_flags,                  \n",
    "                           gamma=0.99,\n",
    "                           device=device)\n",
    "\n",
    "    loss.backward()\n",
    "    grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "    opt.step()\n",
    "    opt.zero_grad()\n",
    "\n",
    "    if step % loss_freq == 0:\n",
    "        td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "    if step % refresh_target_network_freq == 0:\n",
    "        # Load agent weights into target_network\n",
    "        target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "    if step % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        mean_rw_history.append(evaluate(\n",
    "            make_env(env_name, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "        )\n",
    "\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "              (len(exp_replay), agent.epsilon))\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean reward per episode\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(td_loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"TD loss history (smoothened)\")\n",
    "        plt.plot(smoothen(td_loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 348.93333333333334\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state = env.reset()\n",
    "    reward = 0\n",
    "    while True:\n",
    "        qvalues = agent.get_qvalues([state])\n",
    "        action = qvalues.argmax(axis=-1)[0]\n",
    "        state, r, done, _ = env.step(action)\n",
    "        reward += r\n",
    "        if done:\n",
    "            print('Got reward: {}'.format(reward))\n",
    "            break\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got reward: 327.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/6_1/'\n",
    "env = make_env(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO\n",
    "\n",
    "# Try to run this on another environment of your choice from OpenAI Gym\n",
    "# read the accompanying text and try to enahnce the network using various variants\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We can improve this agent with many tricks. As we go along, we will be implementing many of these variants."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
